home *** CD-ROM | disk | FTP | other *** search
/ Aminet 35 / Aminet 35 (2000)(Schatztruhe)[!][Feb 2000].iso / Aminet / game / shoot / ADescentSrc.lha / descent / main / digi.c < prev    next >
C/C++ Source or Header  |  1998-04-03  |  41KB  |  1,464 lines
  1. /*
  2. THE COMPUTER CODE CONTAINED HEREIN IS THE SOLE PROPERTY OF PARALLAX
  3. SOFTWARE CORPORATION ("PARALLAX").  PARALLAX, IN DISTRIBUTING THE CODE TO
  4. END-USERS, AND SUBJECT TO ALL OF THE TERMS AND CONDITIONS HEREIN, GRANTS A
  5. ROYALTY-FREE, PERPETUAL LICENSE TO SUCH END-USERS FOR USE BY SUCH END-USERS
  6. IN USING, DISPLAYING,  AND CREATING DERIVATIVE WORKS THEREOF, SO LONG AS
  7. SUCH USE, DISPLAY OR CREATION IS FOR NON-COMMERCIAL, ROYALTY OR REVENUE
  8. FREE PURPOSES.  IN NO EVENT SHALL THE END-USER USE THE COMPUTER CODE
  9. CONTAINED HEREIN FOR REVENUE-BEARING PURPOSES.  THE END-USER UNDERSTANDS
  10. AND AGREES TO THE TERMS HEREIN AND ACCEPTS THE SAME BY USE OF THIS FILE.  
  11. COPYRIGHT 1993-1998 PARALLAX SOFTWARE CORPORATION.  ALL RIGHTS RESERVED.
  12. */
  13. /*
  14.  * $Source: /usr/CVS/descent/main/digi.c,v $
  15.  * $Revision: 1.3 $
  16.  * $Author: hfrieden $
  17.  * $Date: 1998/04/03 13:32:52 $
  18.  * 
  19.  * Routines to access digital sound hardware
  20.  *
  21.  * $Log: digi.c,v $
  22.  * Revision 1.3  1998/04/03 13:32:52  hfrieden
  23.  * Added error messages
  24.  *
  25.  * Revision 1.2  1998/03/13 23:44:52  tfrieden
  26.  * *** empty log message ***
  27.  *
  28.  * Revision 1.1.1.1  1998/03/03 15:12:21  nobody
  29.  * reimport after crash from backup
  30.  *
  31.  * Revision 1.6  1998/02/21 23:15:54  hfrieden
  32.  * *** empty log message ***
  33.  *
  34.  * Revision 1.5  1998/02/18 17:15:23  hfrieden
  35.  * AHI Support finally working. Digital sound available
  36.  *
  37.  * Revision 1.4  1998/02/17 18:59:40  hfrieden
  38.  * Bugfixes on AHI driver
  39.  *
  40.  * Revision 1.3  1998/02/16 22:02:01  hfrieden
  41.  * Almost working AHI support
  42.  *
  43.  * Revision 1.2  1998/02/14 10:07:40  hfrieden
  44.  * AHI sound support added
  45.  *
  46.  */
  47.  
  48. #pragma off (unreferenced)
  49. static char rcsid[] = "$Id: digi.c,v 1.3 1998/04/03 13:32:52 hfrieden Exp $";
  50. #pragma on (unreferenced)
  51.  
  52. #include <stdlib.h>
  53. #include <stdio.h>
  54. #include <fcntl.h>
  55. #include <malloc.h>
  56. #include <string.h>
  57. #include <ctype.h>
  58.  
  59. #include "fix.h"
  60. #include "object.h"
  61. #include "mono.h"
  62. #include "timer.h"
  63. #include "joy.h"
  64. #include "digi.h"
  65. #include "sounds.h"
  66. #include "args.h"
  67. #include "key.h"
  68. #include "newdemo.h"
  69. #include "game.h"
  70. #include "error.h"
  71. #include "wall.h"
  72. #include "cfile.h"
  73. #include "piggy.h"
  74. #include "text.h"
  75. #include "gauges.h"
  76. #include "byteswap.h"
  77.  
  78. #include <exec/exec.h>
  79. #include <devices/ahi.h>
  80. #include <clib/alib_protos.h>
  81. #include <clib/exec_protos.h>
  82. #include <clib/utility_protos.h>
  83. #include <inline/exec.h>
  84. #include <inline/ahi.h>
  85. #include <inline/ahi_sub.h>
  86. #include <inline/utility.h>
  87.  
  88.  
  89. // #pragma pack (4);                        // Use 32-bit packing!
  90. #pragma off (check_stack);          // No stack checking!
  91. //*************************************************
  92. //#include "sos.h"
  93. //#include "sosm.h"
  94. //The above two includes are part of a commercial 
  95. //sound library, so they cannot be included in a public 
  96. //release of the source code. -KRB
  97. //#include "no_sos.h" //Added by KRB
  98. //*************************************************
  99. #include "kconfig.h"
  100. //#include "soscomp.h"
  101.  
  102. #define hp  HUD_init_message
  103.  
  104. #define DIGI_PAUSE_BROKEN 1     //if this is defined, don't pause MIDI songs
  105.  
  106. #define _DIGI_SAMPLE_FLAGS (_VOLUME | _PANNING )
  107.  
  108. #define _DIGI_MAX_VOLUME (16384)    //16384
  109.  
  110. // patch files
  111. #define  _MELODIC_PATCH       "melodic.bnk"
  112. #define  _DRUM_PATCH          "drum.bnk"
  113. #define  _DIGDRUM_PATCH       "drum32.dig"
  114.  
  115.  
  116. static int  Digi_initialized        = 0;
  117. static int  digi_atexit_called  = 0;            // Set to 1 if atexit(digi_close) was called
  118.  
  119. int ahidigi_audio_mode = AHI_DEFAULT_ID;
  120. int ahidigi_audio_freq = AHI_DEFAULT_FREQ;
  121. int ahidigi_next_channel = 0;
  122. int ahidigi_max_channels = 16;
  123. int ahidigi_volume_boost = 1;
  124. ULONG ahidigi_stereo = 0;
  125. ULONG ahidigi_panning = 0;
  126.  
  127. int digi_driver_board               = 100;      // Hey, this is an Amiga, man.
  128. int digi_driver_port                    = 100;
  129. int digi_driver_irq                 = 100;
  130. int digi_driver_dma                 = 100;
  131. int digi_midi_type                  = 0;            // Midi driver type
  132. int digi_midi_port                  = 0;            // Midi driver port
  133. static int digi_max_channels        = 16;
  134. static int digi_driver_rate     = 11025;            // rate to use driver at
  135. static int digi_dma_buffersize  = 4096;         // size of the dma buffer to use (4k)
  136. int digi_timer_rate                 = 9943;         // rate for the timer to go off to handle the driver system (120 Hz)
  137. int digi_lomem                      = 0;
  138. static int digi_volume              = _DIGI_MAX_VOLUME;     // Max volume
  139. static int midi_volume              = 128/2;                        // Max volume
  140. static int midi_system_initialized      = 0;
  141. static int digi_system_initialized      = 0;
  142. static int timer_system_initialized     = 0;
  143. static int digi_sound_locks[MAX_SOUNDS];
  144. char digi_last_midi_song[16] = "";
  145. char digi_last_melodic_bank[16] = "";
  146. char digi_last_drum_bank[16] = "";
  147. typedef char * LPSTR;
  148. //typedef ushort WORD;
  149. LPSTR digi_driver_path = NULL;//Was _NULL -KRB
  150. static WORD                     hSOSDigiDriver = 0xffff;            // handle for the SOS driver being used 
  151. static WORD                     hSOSMidiDriver = 0xffff;            // handle for the loaded MIDI driver
  152. static WORD                     hTimerEventHandle = 0xffff;     // handle for the timer function
  153.  
  154. void digi_reset_digi_sounds(void);
  155.  
  156. static void * lpInstruments = NULL;     // pointer to the instrument file
  157. static int InstrumentSize = 0;
  158. static void * lpDrums = NULL;               // pointer to the drum file
  159. static int DrumSize = 0;
  160. // track mapping structure, this is used to map which track goes
  161. // out which device. this can also be mapped by the name of the 
  162. // midi track. to map by the name of the midi track use the define
  163. // _MIDI_MAP_TRACK for each of the tracks 
  164. /*
  165. static _SOS_MIDI_TRACK_DEVICE   sSOSTrackMap = { 
  166.    _MIDI_MAP_TRACK, _MIDI_MAP_TRACK, _MIDI_MAP_TRACK, _MIDI_MAP_TRACK, 
  167.    _MIDI_MAP_TRACK, _MIDI_MAP_TRACK, _MIDI_MAP_TRACK, _MIDI_MAP_TRACK, 
  168.    _MIDI_MAP_TRACK, _MIDI_MAP_TRACK, _MIDI_MAP_TRACK, _MIDI_MAP_TRACK, 
  169.    _MIDI_MAP_TRACK, _MIDI_MAP_TRACK, _MIDI_MAP_TRACK, _MIDI_MAP_TRACK,
  170.    _MIDI_MAP_TRACK, _MIDI_MAP_TRACK, _MIDI_MAP_TRACK, _MIDI_MAP_TRACK, 
  171.    _MIDI_MAP_TRACK, _MIDI_MAP_TRACK, _MIDI_MAP_TRACK, _MIDI_MAP_TRACK, 
  172.    _MIDI_MAP_TRACK, _MIDI_MAP_TRACK, _MIDI_MAP_TRACK, _MIDI_MAP_TRACK, 
  173.    _MIDI_MAP_TRACK, _MIDI_MAP_TRACK, _MIDI_MAP_TRACK, _MIDI_MAP_TRACK 
  174. };
  175. */
  176. // handle for the initialized MIDI song
  177. WORD     wSongHandle = 0xffff;         
  178. ubyte       *SongData=NULL;
  179. int     SongSize;
  180.  
  181.  
  182. #define SOF_USED                1       // Set if this sample is used
  183. #define SOF_PLAYING         2       // Set if this sample is playing on a channel
  184. #define SOF_LINK_TO_OBJ     4       // Sound is linked to a moving object. If object dies, then finishes play and quits.
  185. #define SOF_LINK_TO_POS     8       // Sound is linked to segment, pos
  186. #define SOF_PLAY_FOREVER    16      // Play forever (or until level is stopped), otherwise plays once
  187.  
  188. typedef struct sound_object {
  189.     short           signature;      // A unique signature to this sound
  190.     ubyte           flags;          // Used to tell if this slot is used and/or currently playing, and how long.
  191.     fix         max_volume;     // Max volume that this sound is playing at
  192.     fix         max_distance;   // The max distance that this sound can be heard at...
  193.     int         volume;         // Volume that this sound is playing at
  194.     int         pan;                // Pan value that this sound is playing at
  195.     WORD            handle;         // What handle this sound is playing on.  Valid only if SOF_PLAYING is set.
  196.     short           soundnum;       // The sound number that is playing
  197.     int             channel;        // AHI channel number this sound is playing on
  198.     union { 
  199.         struct {
  200.             short           segnum;             // Used if SOF_LINK_TO_POS field is used
  201.             short           sidenum;                
  202.             vms_vector  position;
  203.         } s1;
  204.         struct {
  205.             short           objnum;             // Used if SOF_LINK_TO_OBJ field is used
  206.             short           objsignature;
  207.         } s2;
  208.     } u;
  209. } sound_object;
  210.  
  211. #define _segnum         u.s1.segnum
  212. #define _sidenum        u.s1.sidenum
  213. #define _position       u.s1.position
  214. #define _objnum         u.s2.objnum
  215. #define _objsignature   u.s2.objsignature
  216.  
  217. #define MAX_SOUND_OBJECTS 16
  218. sound_object SoundObjects[MAX_SOUND_OBJECTS];
  219. short next_signature=0;
  220.  
  221. struct MsgPort *AudioPort = NULL;
  222. char AHIDevice = -1;
  223. struct AHIRequest *MasterRequest;
  224. struct Library *AHIBase;
  225. struct AHIAudioCtrl *AudioCtrl;
  226.  
  227. int ChannelMap[32];
  228.  
  229. struct AHIEffMasterVolume ahidigi_master_volume;
  230.  
  231. struct Hook ahidigi_hook;
  232.  
  233. typedef struct ahidigi_param {
  234.     int         nLoop;
  235.     Fixed       Volume;
  236.     int         Size;
  237.     UBYTE *     Data;
  238.     sposition   Pan;
  239. } ahidigi_param;
  240.  
  241. extern struct Library *SysBase;
  242.  
  243. #define AHIDIGI_PAN_CENTER  0x8000L
  244. #define AHIDIGI_VOL_MAX     0x10000L
  245.  
  246. int digi_sounds_initialized=0;
  247. //this block commented out by KRB
  248.  
  249.  
  250. void * testLoadFile( char * szFileName, int * length );
  251.  
  252. void sosMIDICallback( WORD PassedSongHandle );
  253. void sosEndMIDICallback();
  254.  
  255. int digi_xlat_sound(int soundno)
  256. {
  257.  
  258.     if ( soundno < 0 ) return -1;
  259.  
  260.     if ( digi_lomem )   {
  261.         soundno = AltSounds[soundno];
  262.         if ( soundno == 255 ) return -1;
  263.     }
  264.     return Sounds[soundno];
  265.  
  266. }
  267.  
  268.  
  269. void digi_close_midi()
  270. {
  271. /*
  272.     if (digi_midi_type>0)   {
  273.         if (wSongHandle < 0xffff)   {
  274.            // stop the last MIDI song from playing
  275.             sosMIDIStopSong( wSongHandle );
  276.            // uninitialize the last MIDI song
  277.             sosMIDIUnInitSong( wSongHandle );
  278.             wSongHandle = 0xffff;
  279.         }
  280.         if (SongData)   {
  281.             if (!dpmi_unlock_region(SongData, SongSize))    {
  282.                 mprintf( (1, "Error unlocking midi file" ));
  283.             }
  284.             free(SongData);
  285.             SongData = NULL;
  286.         }
  287.        // reset the midi driver and
  288.        // uninitialize the midi driver and tell it to free the memory allocated
  289.        // for the driver
  290.         if ( hSOSMidiDriver < 0xffff )  {
  291.            sosMIDIResetDriver( hSOSMidiDriver );
  292.         sosMIDIUnInitDriver( hSOSMidiDriver, _TRUE  );
  293.             hSOSMidiDriver = 0xffff;
  294.         }
  295.  
  296.         if ( midi_system_initialized )  {
  297.            // uninitialize the MIDI system
  298.            sosMIDIUnInitSystem(); 
  299.             midi_system_initialized = 0;
  300.         }
  301.     }
  302. */
  303. }
  304.  
  305. void digi_close_digi()
  306. {
  307.     if (AHIBase && AudioCtrl) {
  308.         ahidigi_master_volume.ahie_Effect = AHIET_CANCEL|AHIET_MASTERVOLUME;
  309.         AHI_SetEffect(&ahidigi_master_volume, AudioCtrl);
  310.     }
  311.     if (!AHIDevice) {
  312.         //AbortIO((struct IORequest *)MasterRequest);
  313.         CloseDevice((struct IORequest *)MasterRequest);
  314.         AHIDevice = -1;
  315.     }
  316.     if (AudioCtrl)     AHI_FreeAudio(AudioCtrl);
  317.     if (MasterRequest) DeleteIORequest((struct IORequest *)MasterRequest);
  318.     if (AudioPort)     DeleteMsgPort(AudioPort);
  319. }
  320.  
  321.  
  322. void digi_close()
  323. {
  324.     if (!Digi_initialized) return;
  325.     Digi_initialized = 0;
  326.  
  327.     digi_close_midi();
  328.     digi_close_digi();
  329.  
  330.     if ( digi_system_initialized )  {
  331.         digi_system_initialized = 0;
  332.     }
  333. }
  334.  
  335. extern int loadpats( char * filename );
  336.  
  337. int digi_load_fm_banks( char * melodic_file, char * drum_file )
  338. {   
  339. /*
  340.    WORD     wError;                 // error code returned from functions
  341.  
  342.     // set the instrument file for the MIDI driver to use, since we are using
  343.     // the FM driver two instrument files are needed, the first is for 
  344.     // all melodic instruments and the second is for events on channel 10
  345.     // which is the drum track.
  346.     // set the drum instruments
  347.     if (lpInstruments)  {
  348.         dpmi_unlock_region(lpInstruments, InstrumentSize);
  349.         free( lpInstruments );
  350.     }
  351.             
  352.     lpInstruments = testLoadFile( melodic_file, &InstrumentSize );
  353.     if ( !lpInstruments )   {
  354.         printf( "%s '%s'\n", TXT_SOUND_ERROR_OPEN, melodic_file );
  355.         return 0;
  356.     }
  357.  
  358.     if (!dpmi_lock_region(lpInstruments, InstrumentSize))   {
  359.         printf( "%s '%s', ptr=0x%8x, len=%d bytes\n", TXT_SOUND_ERROR_LOCK, melodic_file, lpInstruments, InstrumentSize );
  360.         return 0;
  361.     }
  362.     
  363.     if( ( wError =  sosMIDISetInsData( hSOSMidiDriver, lpInstruments, 0x01  ) ) )   {
  364.         printf( "%s %s \n", TXT_SOUND_ERROR_HMI, sosGetErrorString( wError ) );
  365.         return 0;
  366.     }
  367.     
  368.     if (lpDrums)    {
  369.         dpmi_unlock_region(lpDrums, DrumSize);
  370.         free( lpDrums );
  371.     }
  372.             
  373.     lpDrums = testLoadFile( drum_file, &DrumSize );
  374.     if ( !lpDrums ) {
  375.         printf( "%s '%s'\n", TXT_SOUND_ERROR_OPEN, drum_file );
  376.         return 0;
  377.     }
  378.  
  379.     if (!dpmi_lock_region(lpDrums, DrumSize))   {
  380.         printf( "%s  '%s', ptr=0x%8x, len=%d bytes\n", TXT_SOUND_ERROR_LOCK_DRUMS, drum_file, lpDrums, DrumSize );
  381.         return 0;
  382.     }
  383.     
  384.      // set the drum instruments
  385.     if( ( wError =  sosMIDISetInsData( hSOSMidiDriver, lpDrums, 0x01  ) ) ) {
  386.         printf( "%s %s\n", TXT_SOUND_ERROR_HMI, sosGetErrorString( wError ) );
  387.         return 0;
  388.     }
  389.     
  390.     return 1;
  391. */
  392.     return 0;//KRB Comment out...
  393.  
  394. }
  395.  
  396. int digi_init_midi()
  397. {
  398. /*
  399.    WORD     wError;                 // error code returned from functions
  400.     _SOS_MIDI_INIT_DRIVER           sSOSMIDIInitDriver; // structure for the MIDI driver initialization function 
  401.     _SOS_MIDI_HARDWARE              sSOSMIDIHardware;   // structure for the MIDI driver hardware
  402.  
  403.     if ( digi_midi_type > 0 )   {
  404.         // Lock the TrackMap array, since HMI references it in an interrupt.
  405.         if (!dpmi_lock_region ( &sSOSTrackMap, sizeof(sSOSTrackMap)) )  {
  406.             printf( "%s\n", TXT_SOUND_ERROR_MIDI);
  407.             digi_close();
  408.             return 1;
  409.         }
  410.  
  411. //      if (!dpmi_lock_region ((void near *)sosMIDICallback, (char *)sosEndMIDICallback - (char near *)sosMIDICallback))    {
  412.         if (!dpmi_lock_region ((void near *)sosMIDICallback, 4*1024) )  {
  413.             printf( "%s\n", TXT_SOUND_ERROR_MIDI_CALLBACK);
  414.             digi_close();
  415.             return 1;
  416.         }
  417.  
  418.        // initialize the MIDI system
  419.        sosMIDIInitSystem( digi_driver_path, _SOS_DEBUG_NORMAL );
  420.         midi_system_initialized = 1;
  421.  
  422.        // set the pointer to the driver memory for the MIDI driver to 
  423.        // _NULL. this will tell the load driver routine to allocate new
  424.        // memory for the MIDI driver
  425.        sSOSMIDIInitDriver.lpDriverMemory  = _NULL;
  426.         sSOSMIDIInitDriver.sDIGIInitInfo = _NULL;
  427.     
  428.         sSOSMIDIHardware.wPort = digi_midi_port;
  429.     
  430.        // load and initialize the MIDI driver 
  431.        if( ( wError = sosMIDIInitDriver( digi_midi_type, &sSOSMIDIHardware, &sSOSMIDIInitDriver, &hSOSMidiDriver ) ) )  {
  432.           printf( "SOUND: (HMI) '%s'\n", sosGetErrorString( wError ) );
  433.             digi_close();
  434.           return 1;
  435.        }
  436.         sosMIDIEnableChannelStealing( _FALSE );
  437.     }
  438.     return 0;
  439. */
  440.     return 0;//KRB Comment out...
  441.  
  442. }
  443.  
  444. void __interrupt __saveds ahidigi_callback(struct Hook *hook __asm("a0"), struct AHIAudioCtrl *actrl __asm("a2"), struct AHISoundMessage *msg __asm("a1"))
  445. {
  446.     ChannelMap[msg->ahism_Channel] = 1-ChannelMap[msg->ahism_Channel];
  447. }
  448.  
  449. int digi_init_digi()
  450. {
  451.     int i;
  452.     ULONG error;
  453.  
  454.     AudioPort = CreateMsgPort();
  455.     if (!AudioPort) return 1;
  456. #ifdef DEBUG_SOUND
  457.     printf("digi_init_digi: Message Port created\n");
  458. #endif
  459.  
  460.     MasterRequest = (struct AHIRequest *)CreateIORequest(AudioPort, sizeof(struct AHIRequest));
  461.     if (MasterRequest) {
  462. #ifdef DEBUG_SOUND
  463.     printf("digi_init_digi: IORequest created\n");
  464. #endif
  465.         MasterRequest -> ahir_Version = 4;
  466.         AHIDevice = (char)OpenDevice((unsigned char *)AHINAME,
  467.             (unsigned long)AHI_NO_UNIT, (struct IORequest *)MasterRequest, 0);
  468.     }
  469.  
  470.     if (AHIDevice) {
  471. #ifdef DEBUG_SOUND
  472.     printf("digi_init_digi: AHIDevice open error %d\n", AHIDevice);
  473. #endif
  474.         if (MasterRequest) DeleteIORequest((struct IORequest *)MasterRequest);
  475.         if (AudioPort) DeleteMsgPort(AudioPort);
  476.         printf("FATAL ERROR: Cannot initalized AHI device\n");
  477.         return 1;
  478.     }
  479.  
  480.     AHIBase = (struct Library *)MasterRequest->ahir_Std.io_Device;
  481. #ifdef DEBUG_SOUND
  482.     printf("digi_init_digi: AHIDevice created, allocating audio\n");
  483. #endif
  484.  
  485.     ahidigi_hook.h_Entry = (HOOKFUNC)ahidigi_callback;
  486.     ahidigi_hook.h_SubEntry = 0;
  487.  
  488.     AudioCtrl = AHI_AllocAudio(
  489.         AHIA_AudioID,       ahidigi_audio_mode,
  490.         AHIA_MixFreq,       ahidigi_audio_freq,
  491.         AHIA_Channels,      (ULONG)ahidigi_max_channels,
  492.         AHIA_Sounds,        30,
  493.         //AHIA_SoundFunc,     (ULONG)&ahidigi_hook,
  494.     TAG_DONE);
  495.  
  496. #ifdef DEBUG_SOUND
  497.     printf("digi_init_digi: AudioCtrl = %d\n", AudioCtrl);
  498. #endif
  499.  
  500.     if (AudioCtrl == NULL) {
  501.         printf("FATAL ERROR: Cannot initialize AudioCtrl\n");
  502.         return 1;
  503.     }
  504. #ifdef DEBUG_SOUND
  505.     printf("digi_init_digi: AudioCtrl allocated and done\n");
  506. #endif
  507.  
  508.     AHI_GetAudioAttrs(ahidigi_audio_mode, NULL,
  509.         AHIDB_Stereo,   (ULONG)&ahidigi_stereo,
  510.         AHIDB_Panning,  (ULONG)&ahidigi_panning,
  511.     TAG_DONE);
  512.  
  513.  
  514.     for (i=0; i<32; i++) ChannelMap[i] = 0;
  515.  
  516.     ahidigi_master_volume.ahie_Effect = AHIET_MASTERVOLUME;
  517.     //i = (ahidigi_stereo && !ahidigi_panning) ? 4 : 2;
  518.     ahidigi_master_volume.ahiemv_Volume = ahidigi_volume_boost * 65535;
  519.     error = AHI_SetEffect(&ahidigi_master_volume, AudioCtrl);
  520.  
  521.     digi_set_digi_volume ( (Config_digi_volume * 32768)/8);
  522.  
  523. #ifdef DEBUG_SOUND
  524.     printf("Done\n");
  525. #endif
  526.  
  527.     return 0;
  528. }
  529.  
  530. int digi_init()
  531. {
  532.     int i;
  533.     if ( FindArg( "-nomusic" )) 
  534.         digi_midi_type = 0;
  535.  
  536.  
  537.     Digi_initialized = 1;
  538.     digi_system_initialized = 1;
  539.  
  540.     if (digi_init_midi()) return 1;
  541.     if (digi_init_digi()) return 1;
  542.  
  543.     if (!digi_atexit_called)    {
  544.         atexit( digi_close );
  545.         digi_atexit_called = 1;
  546.     }
  547.  
  548.     digi_init_sounds();
  549.     digi_set_midi_volume( midi_volume );
  550.  
  551.     for (i=0; i<MAX_SOUNDS; i++ )
  552.         digi_sound_locks[i] = 0;
  553.     digi_reset_digi_sounds();
  554.  
  555.     return 0;
  556. }
  557.  
  558. // Toggles sound system on/off
  559. void digi_reset()   
  560. {
  561.     if ( Digi_initialized ) {
  562.         digi_reset_digi_sounds();
  563.         digi_close();
  564.         mprintf( (0, "Sound system DISABLED.\n" ));
  565.     } else {
  566.         digi_init();
  567.         mprintf( (0, "Sound system ENABLED.\n" ));
  568.     }
  569. }
  570.  
  571. int digi_total_locks = 0;
  572.  
  573. ubyte * digi_lock_sound_data( int soundnum )
  574. {
  575. /*
  576.     int i;
  577.  
  578.     if ( !Digi_initialized ) return NULL;
  579.     if ( digi_driver_board <= 0 )   return NULL;
  580.  
  581.     if ( digi_sound_locks[soundnum] == 0 )  {
  582.         digi_total_locks++;
  583.         //mprintf(( 0, "Total sound locks = %d\n", digi_total_locks ));
  584.         i = dpmi_lock_region( GameSounds[soundnum].data, GameSounds[soundnum].length );
  585.         if ( !i ) Error( "Error locking sound %d\n", soundnum );
  586.     }
  587.     digi_sound_locks[soundnum]++;
  588.     return GameSounds[soundnum].data;
  589. */
  590.     digi_total_locks=digi_total_locks;//blah -KRB
  591.     return 0;//KRB Comment out...
  592.  
  593. }
  594.  
  595. void digi_unlock_sound_data( int soundnum )
  596. {
  597. /*
  598.     int i;
  599.  
  600.     if ( !Digi_initialized ) return;
  601.     if ( digi_driver_board <= 0 )   return;
  602.  
  603.     Assert( digi_sound_locks[soundnum] > 0 );
  604.  
  605.     if ( digi_sound_locks[soundnum] == 1 )  {
  606.         digi_total_locks--;
  607.         //mprintf(( 0, "Total sound locks = %d\n", digi_total_locks ));
  608.         i = dpmi_unlock_region( GameSounds[soundnum].data, GameSounds[soundnum].length );
  609.         if ( !i ) Error( "Error unlocking sound %d\n", soundnum );
  610.     }
  611.     digi_sound_locks[soundnum]--;
  612. */
  613. }
  614. /*
  615. static int next_handle = 0;
  616. static WORD SampleHandles[32] = { 0xffff, 0xffff, 0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff };
  617. static int SoundNums[32] = { -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 };
  618. static uint SoundVolumes[32] = { -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 };
  619. //This block commented out by KRB
  620. */
  621. void digi_reset_digi_sounds(void)
  622. {
  623.     int i;
  624.  
  625.     if ( !Digi_initialized ) return;
  626.  
  627.     for (i=0; i<ahidigi_max_channels; i++)
  628.         AHI_SetSound((UWORD)i, AHI_NOSOUND, 0, 0, AudioCtrl, AHISF_IMM);
  629.  
  630.     for (i=0; i<32; i++) ChannelMap[i] = 0;
  631.     AHI_ControlAudio(AudioCtrl,
  632.         AHIC_Play, TRUE,
  633.     TAG_DONE);
  634.  
  635. }
  636.  
  637. void reset_sounds_on_channel( int channel )
  638. {
  639.     if ( !Digi_initialized ) return;
  640.     AHI_SetSound((UWORD)channel, AHI_NOSOUND, 0, 0, AudioCtrl, AHISF_IMM);
  641.     ChannelMap[channel] = 0;
  642.  
  643. }
  644.  
  645.  
  646. void digi_set_max_channels(int n)
  647. {
  648.     return;
  649. /*    digi_max_channels   = n;
  650.  
  651.     if ( digi_max_channels < 1 ) 
  652.         digi_max_channels = 1;
  653.     if ( digi_max_channels > (32-MAX_SOUND_OBJECTS) ) 
  654.         digi_max_channels = (32-MAX_SOUND_OBJECTS);
  655.  
  656.     if ( !Digi_initialized ) return;
  657.  
  658.     digi_reset_digi_sounds();*/
  659. }
  660.  
  661. int digi_get_max_channels()
  662. {
  663.     return ahidigi_max_channels;
  664.  
  665. }
  666.  
  667.  
  668. WORD digi_start_sound(ahidigi_param *sampledata, short soundnum )
  669.  
  670. {
  671.     int i,j;
  672.  
  673.     struct AHISampleInfo info;
  674.  
  675.     unsigned long volume;
  676.  
  677.     if ( !Digi_initialized ) return -1;
  678.  
  679.     // Start by finding a free channel
  680.  
  681.     i = ahidigi_next_channel;
  682.     j=0;
  683.     do {
  684.         ahidigi_next_channel++; j++;
  685.         if (ahidigi_next_channel == ahidigi_max_channels)
  686.             ahidigi_next_channel = 0;
  687.         if (ChannelMap[ahidigi_next_channel] == 0) break;
  688.     } while (j<32);
  689.  
  690.     info.ahisi_Type = AHIST_M8U;
  691.     info.ahisi_Address = sampledata->Data;
  692.     info.ahisi_Length = sampledata->Size;
  693.     AHI_LoadSound(i, AHIST_SAMPLE, &info, AudioCtrl);
  694.  
  695.     volume = (unsigned long)digi_volume*(unsigned long)(sampledata->Volume) / 65535UL;
  696.  
  697.     #ifdef DEBUG_SOUND
  698.     hp("Volume: %d (%d)",volume, i);
  699.     #endif
  700.  
  701.     if (sampledata->nLoop != 0) {
  702.         AHI_Play(AudioCtrl,
  703.             AHIP_BeginChannel,  i,
  704.             AHIP_Freq,      (ULONG)digi_driver_rate,
  705.             AHIP_Vol,       (ULONG)volume,
  706.             AHIP_Sound,     i,
  707.             AHIP_Pan,       sampledata->Pan,
  708.             AHIP_LoopFreq,  (ULONG)digi_driver_rate,
  709.             AHIP_LoopVol,   sampledata->Volume,
  710.             AHIP_LoopPan,   sampledata->Pan,
  711.             AHIP_EndChannel,NULL,
  712.         TAG_DONE);
  713.     } else {
  714.         AHI_Play(AudioCtrl,
  715.             AHIP_BeginChannel,  i,
  716.             AHIP_Freq,      (ULONG)digi_driver_rate,
  717.             AHIP_Vol,       (ULONG)volume,
  718.             AHIP_Pan,       sampledata->Pan,
  719.             AHIP_Sound,     i,
  720.             AHIP_LoopSound, AHI_NOSOUND,
  721.             AHIP_EndChannel,NULL,
  722.         TAG_DONE);
  723.         //AHI_SetSound(i, AHI_NOSOUND, 0,0, AudioCtrl, 0);
  724.     }
  725.  
  726.     #ifdef DEBUG_SOUND
  727.     {
  728.         int j;
  729.         char xxx[40];
  730.         for (j=0; j<ahidigi_max_channels; j++) xxx[j]='0'+ChannelMap[j];
  731.         xxx[j]=0;
  732.         hp("channels: %s", xxx);
  733.     }
  734.     #endif
  735.  
  736.     return i;
  737.  
  738. }
  739.  
  740. int digi_is_sound_playing(int soundno)
  741. {
  742.     return 0;//KRB Comment out...
  743. }
  744.  
  745. void digi_play_sample_once( int soundno, fix max_volume )   
  746. {
  747.     digi_sound *snd;
  748.     ahidigi_param params;
  749.  
  750. #ifdef NEWDEMO
  751.     if ( Newdemo_state == ND_STATE_RECORDING )
  752.         newdemo_record_sound( soundno );
  753. #endif
  754.     soundno = digi_xlat_sound(soundno);
  755.  
  756.     if (!Digi_initialized) return;
  757.  
  758.     if (soundno < 0 ) return;
  759.     snd = &GameSounds[soundno];
  760.  
  761.     params.nLoop        = 0;
  762.     params.Volume       = max_volume;
  763.     params.Size         = snd->length;
  764.     params.Data         = snd->data;
  765.     params.Pan          = AHIDIGI_PAN_CENTER;
  766.  
  767.     digi_start_sound( ¶ms, soundno );
  768. }
  769.  
  770.  
  771. void digi_play_sample( int soundno, fix max_volume )
  772. {
  773.     digi_play_sample_once(soundno, max_volume);
  774. }
  775.  
  776.  
  777. void digi_play_sample_3d( int soundno, int angle, int volume, int no_dups ) 
  778. {
  779.     digi_sound *snd;
  780.     ahidigi_param params;
  781.  
  782. #ifdef NEWDEMO
  783.     if ( Newdemo_state == ND_STATE_RECORDING )
  784.         newdemo_record_sound( soundno );
  785. #endif
  786.     soundno = digi_xlat_sound(soundno);
  787.  
  788.     if (!Digi_initialized) return;
  789.  
  790.     if (soundno < 0 ) return;
  791.     snd = &GameSounds[soundno];
  792.  
  793.     params.nLoop        = 0;
  794.     params.Volume       = volume;
  795.     params.Size         = snd->length;
  796.     params.Data         = snd->data;
  797.     params.Pan          = angle;
  798.  
  799.  
  800.     digi_start_sound( ¶ms, soundno );
  801.  
  802. /*
  803.     sSOSSampleData.wSamplePanLocation   = angle;            // 0 - 0xFFFF
  804.     sSOSSampleData.wSamplePanSpeed      = 0;
  805.     sSOSSampleData.wVolume                  = fixmuldiv(volume,digi_volume,F1_0);;                  // 0 - 0x7fff
  806. */
  807. }
  808.  
  809. void digi_set_midi_volume( int mvolume )
  810. {
  811. /*
  812.     int old_volume = midi_volume;
  813.  
  814.     if ( mvolume > 127 )
  815.         midi_volume = 127;
  816.     else if ( mvolume < 0 )
  817.         midi_volume = 0;
  818.     else
  819.         midi_volume = mvolume;
  820.  
  821.     if ( (digi_midi_type > 0) && (hSOSMidiDriver < 0xffff) )        {
  822.         if (  (old_volume < 1) && ( midi_volume > 1 ) ) {
  823.             if (wSongHandle == 0xffff )
  824.                 digi_play_midi_song( digi_last_midi_song, digi_last_melodic_bank, digi_last_drum_bank, 1 );
  825.         }
  826.         _disable();
  827.         sosMIDISetMasterVolume(midi_volume);
  828.         _enable();
  829.     }
  830. */
  831. }
  832.  
  833. void digi_set_digi_volume( int dvolume )
  834. {
  835.     if ( !Digi_initialized ) return;
  836.  
  837.     if (dvolume <= 0)
  838.         digi_volume = 0;
  839.     else
  840.         digi_volume = dvolume*2-1;
  841.  
  842.     digi_sync_sounds();
  843.  
  844. }
  845.  
  846.  
  847. // 0-0x7FFF 
  848. void digi_set_volume( int dvolume, int mvolume )    
  849. {
  850.  
  851. #ifdef DEBUG_SOUND
  852.     printf("digi_set__volume(%d, %d)\n", dvolume, mvolume);
  853. #endif
  854.  
  855.     digi_set_midi_volume( mvolume );
  856.     digi_set_digi_volume( dvolume );
  857. }
  858.  
  859. // allocate memory for file, load file, create far pointer
  860. // with DS in selector.
  861. void * testLoadFile( char * szFileName, int * length )
  862. {
  863. /*
  864.    PSTR  pDataPtr;
  865.     CFILE * fp;
  866.     
  867.    // open file
  868.    fp  =  cfopen( szFileName, "rb" );
  869.     if ( !fp ) return NULL;
  870.  
  871.    *length  =  cfilelength(fp);
  872.  
  873.    pDataPtr =  malloc( *length );
  874.     if ( !pDataPtr ) return NULL;
  875.  
  876.    // read in driver
  877.    cfread( pDataPtr, *length, 1, fp);
  878.  
  879.    // close driver file
  880.    cfclose( fp );
  881.  
  882.    // return 
  883.    return( pDataPtr );
  884.    */
  885.    return NULL;//KRB Comment out...
  886. }
  887.  
  888.  
  889. // ALL VARIABLES IN HERE MUST BE LOCKED DOWN!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  890. void sosMIDICallback( WORD PassedSongHandle )
  891. {
  892.     //sosMIDIStartSong(PassedSongHandle);
  893.     return;//KRB comment out
  894. } 
  895.  
  896. void sosEndMIDICallback()       // Used to mark the end of sosMIDICallBack
  897. {
  898. }
  899.  
  900. void digi_stop_current_song()
  901. {
  902. /*
  903.     // Stop last song...
  904.     if (wSongHandle < 0xffff )  {
  905.        // stop the last MIDI song from playing
  906.         sosMIDIStopSong( wSongHandle );
  907.        // uninitialize the last MIDI song
  908.         sosMIDIUnInitSong( wSongHandle );
  909.         wSongHandle = 0xffff;
  910.     }
  911.     if (SongData)   {
  912.         if (!dpmi_unlock_region(SongData, SongSize))    {
  913.             mprintf( (1, "Error unlocking midi file" ));
  914.         }
  915.         free(SongData);
  916.         SongData = NULL;
  917.     }
  918. */
  919. }
  920.  
  921.  
  922. void digi_play_midi_song( char * filename, char * melodic_bank, char * drum_bank, int loop )
  923. {
  924. /*
  925.     int i;
  926.     char fname[128];
  927.    WORD     wError;                 // error code returned from functions
  928.     CFILE       *fp;
  929.  
  930.     // structure to pass sosMIDIInitSong
  931.     _SOS_MIDI_INIT_SONG     sSOSInitSong;
  932.  
  933.     if (!Digi_initialized) return;
  934.     if ( digi_midi_type <= 0 )  return;
  935.  
  936.     digi_stop_current_song();
  937.  
  938.     if ( filename == NULL ) return;
  939.  
  940.     strcpy( digi_last_midi_song, filename );
  941.     strcpy( digi_last_melodic_bank, melodic_bank );
  942.     strcpy( digi_last_drum_bank, drum_bank );
  943.  
  944.     fp = NULL;
  945.  
  946.     if ( (digi_midi_type==_MIDI_FM)||(digi_midi_type==_MIDI_OPL3) ) {   
  947.         int sl;
  948.         sl = strlen( filename );
  949.         strcpy( fname, filename );  
  950.         fname[sl-1] = 'q';
  951.         fp = cfopen( fname, "rb" );
  952.     }
  953.  
  954.     if ( !fp  ) {
  955.         fp = cfopen( filename, "rb" );
  956.         if (!fp) {
  957.             mprintf( (1, "Error opening midi file, '%s'", filename ));
  958.             return;
  959.         }
  960.     }
  961.     if ( midi_volume < 1 )      {
  962.         cfclose(fp);
  963.         return;             // Don't play song if volume == 0;
  964.     }
  965.     SongSize = cfilelength( fp );
  966.     SongData    = malloc( SongSize );
  967.     if (SongData==NULL) {
  968.         cfclose(fp);
  969.         mprintf( (1, "Error mallocing %d bytes for '%s'", SongSize, filename ));
  970.         return;
  971.     }
  972.     if ( cfread (  SongData, SongSize, 1, fp )!=1)  {
  973.         mprintf( (1, "Error reading midi file, '%s'", filename ));
  974.         cfclose(fp);
  975.         free(SongData);
  976.         SongData=NULL;
  977.         return;
  978.     }
  979.     cfclose(fp);
  980.  
  981.     if ( (digi_midi_type==_MIDI_FM)||(digi_midi_type==_MIDI_OPL3) ) {   
  982.         if ( !digi_load_fm_banks(melodic_bank, drum_bank) ) {
  983.             return;
  984.         }
  985.     }
  986.         
  987.     if (!dpmi_lock_region(SongData, SongSize))  {
  988.         mprintf( (1, "Error locking midi file, '%s'", filename ));
  989.         free(SongData);
  990.         SongData=NULL;
  991.         return;
  992.     }
  993.  
  994.     // setup the song initialization structure
  995.     sSOSInitSong.lpSongData = SongData;
  996.     if ( loop )
  997.         sSOSInitSong.lpSongCallback = sosMIDICallback;
  998.     else
  999.         sSOSInitSong.lpSongCallback = _NULL;
  1000.  
  1001.     for ( i=0; i<32; i++ )
  1002.         sSOSTrackMap.wTrackDevice[i] = _MIDI_MAP_TRACK;
  1003.             
  1004.     for ( i=0; i<_SOS_MIDI_MAX_TRACKS; i++ )
  1005.         _lpSOSMIDITrack[0][i] = _NULL;
  1006.  
  1007.     //initialize the song
  1008.     if( ( wError = sosMIDIInitSong( &sSOSInitSong, &sSOSTrackMap, &wSongHandle ) ) )    {
  1009.         mprintf( (1, "\nHMI Error : %s", sosGetErrorString( wError ) ));
  1010.         free(SongData);
  1011.         SongData=NULL;
  1012.         return;
  1013.     }
  1014.  
  1015.     Assert( wSongHandle == 0 );
  1016.      
  1017.   // start the song playing
  1018.    if( ( wError = sosMIDIStartSong( wSongHandle ) ) ) {
  1019.         mprintf( (1, "\nHMI Error : %s", sosGetErrorString( wError ) ));
  1020.        // uninitialize the last MIDI song
  1021.         sosMIDIUnInitSong( wSongHandle );
  1022.         free(SongData);
  1023.         SongData=NULL;
  1024.         return;
  1025.    }
  1026.    */
  1027. }
  1028.  
  1029. void digi_get_sound_loc( vms_matrix * listener, vms_vector * listener_pos, int listener_seg, vms_vector * sound_pos, int sound_seg, fix max_volume, int *volume, int *pan, fix max_distance )   
  1030. {     
  1031.     vms_vector  vector_to_sound;
  1032.     fix angle_from_ear, cosang,sinang;
  1033.     fix distance;
  1034.     fix path_distance;
  1035.  
  1036.     *volume = 0;
  1037.     *pan = 0;
  1038.  
  1039.     max_distance = (max_distance*5)/4;      // Make all sounds travel 1.25 times as far.
  1040.  
  1041.     //  Warning: Made the vm_vec_normalized_dir be vm_vec_normalized_dir_quick and got illegal values to acos in the fang computation.
  1042.     distance = vm_vec_normalized_dir_quick( &vector_to_sound, sound_pos, listener_pos );
  1043.         
  1044.     if (distance < max_distance )   {
  1045.         int num_search_segs = f2i(max_distance/20);
  1046.         if ( num_search_segs < 1 ) num_search_segs = 1;
  1047.  
  1048.         path_distance = find_connected_distance(listener_pos, listener_seg, sound_pos, sound_seg, num_search_segs, WID_RENDPAST_FLAG );
  1049.         if ( path_distance > -1 )   {
  1050.             *volume = max_volume - fixdiv(path_distance,max_distance);
  1051.             //mprintf( (0, "Sound path distance %.2f, volume is %d / %d\n", f2fl(distance), *volume, max_volume ));
  1052.             if (*volume > 0 )   {
  1053.                 angle_from_ear = vm_vec_delta_ang_norm(&listener->rvec,&vector_to_sound,&listener->uvec);
  1054.                 fix_sincos(angle_from_ear,&sinang,&cosang);
  1055.                 //mprintf( (0, "volume is %.2f\n", f2fl(*volume) ));
  1056.                 if (Config_channels_reversed) cosang *= -1;
  1057.                 *pan = (cosang + F1_0)/2;
  1058.             } else {
  1059.                 *volume = 0;
  1060.             }
  1061.         }
  1062.     }                                                                                     
  1063. }
  1064.  
  1065.  
  1066. void digi_init_sounds()
  1067. {
  1068.     int i;
  1069.  
  1070.     if (!Digi_initialized) return;
  1071.  
  1072.     digi_reset_digi_sounds();
  1073.  
  1074.     for (i=0; i<MAX_SOUND_OBJECTS; i++ )    {
  1075.         if (digi_sounds_initialized) {
  1076.             if ( SoundObjects[i].flags & SOF_PLAYING )  {
  1077.             }
  1078.         }
  1079.         #ifdef DEBUG_SOUND
  1080.         hp("SOF_PLAYING reset on %d");
  1081.         #endif
  1082.         SoundObjects[i].flags = 0;  // Mark as dead, so some other sound can use this sound
  1083.     }
  1084.     digi_sounds_initialized = 1;
  1085.     for (i=0; i<ahidigi_max_channels; i++) ChannelMap[i]=0;
  1086.     #ifdef DEBUG_SOUND
  1087.     hp("Sounds initialized");
  1088.     #endif
  1089. }
  1090.  
  1091. void digi_start_sound_object(int i)
  1092. {
  1093.     ahidigi_param param;
  1094.     if (!Digi_initialized) return;
  1095.  
  1096.  
  1097.     // Sound is not playing, so we must start it again
  1098.     SoundObjects[i].signature=next_signature++;
  1099.                             
  1100.     param.Volume    =   (Fixed)(SoundObjects[i].volume*digi_volume/65535);
  1101.     param.Size      =   GameSounds[SoundObjects[i].soundnum].length;
  1102.     param.Data      =   GameSounds[SoundObjects[i].soundnum].data;
  1103.     param.Pan       =   SoundObjects[i].pan;
  1104.  
  1105.     if (SoundObjects[i].flags & SOF_PLAY_FOREVER )  {
  1106.         param.nLoop = -1;
  1107.     } else param.nLoop = 0;
  1108.  
  1109.     SoundObjects[i].channel = digi_start_sound( ¶m, SoundObjects[i].soundnum );
  1110.  
  1111.     SoundObjects[i].flags |= SOF_PLAYING;
  1112.  
  1113.     ChannelMap[SoundObjects[i].channel] = 1;
  1114.  
  1115. }
  1116.  
  1117. int digi_link_sound_to_object2( int org_soundnum, short objnum, int forever, fix max_volume, fix  max_distance )
  1118. {
  1119.     int i,volume,pan;
  1120.     object * objp;
  1121.     int soundnum;
  1122. #ifdef DEBUG_SOUND
  1123. //    HUD_init_message("to_obj(snum=%d,obj=%d,fevr=%d,maxvol=%d,maxdist=%d)",
  1124. //        org_soundnum, objnum, forever, max_volume, max_distance);
  1125. //    printf("to_obj(org_snum=%d,objnum=%d,forever=%d,max_volume=%d,max_distance=%d)\n",
  1126. //        org_soundnum, objnum, forever, max_volume, max_distance);
  1127. #endif
  1128.  
  1129.     soundnum = digi_xlat_sound(org_soundnum);
  1130.  
  1131.     if ( max_volume < 0 ) return -1;
  1132. //  if ( max_volume > F1_0 ) max_volume = F1_0;
  1133.  
  1134.     if (!Digi_initialized) return -1;
  1135.     if (soundnum < 0 ) return -1;
  1136.     if (GameSounds[soundnum].data==NULL) {
  1137.         Int3();
  1138.         return -1;
  1139.     }
  1140.     if ((objnum<0)||(objnum>Highest_object_index))
  1141.         return -1;
  1142.  
  1143.     if ( !forever ) {
  1144.         // Hack to keep sounds from building up...
  1145.         digi_get_sound_loc( &Viewer->orient, &Viewer->pos, Viewer->segnum, &Objects[objnum].pos, Objects[objnum].segnum, max_volume,&volume, &pan, max_distance );
  1146.         digi_play_sample_3d( org_soundnum, pan, volume, 0 );
  1147.         return -1;
  1148.     }
  1149.  
  1150.     for (i=0; i<MAX_SOUND_OBJECTS; i++ )
  1151.         if (SoundObjects[i].flags==0)
  1152.             break;
  1153.     
  1154.     if (i==MAX_SOUND_OBJECTS) {
  1155.         mprintf((1, "Too many sound objects!\n" ));
  1156.         return -1;
  1157.     }
  1158.  
  1159.     SoundObjects[i].signature=next_signature++;
  1160.     #ifdef DEBUG_SOUND
  1161.     hp("SOF_PLAYING reset on %d");
  1162.     #endif
  1163.     SoundObjects[i].flags = SOF_USED | SOF_LINK_TO_OBJ;
  1164.     if ( forever )
  1165.         SoundObjects[i].flags |= SOF_PLAY_FOREVER;
  1166.     SoundObjects[i]._objnum = objnum;
  1167.     SoundObjects[i]._objsignature = Objects[objnum].signature;
  1168.     SoundObjects[i].max_volume = max_volume;
  1169.     SoundObjects[i].max_distance = max_distance;
  1170.     SoundObjects[i].volume = 0;
  1171.     SoundObjects[i].pan = 0;
  1172.     SoundObjects[i].soundnum = soundnum;
  1173.  
  1174.     objp = &Objects[SoundObjects[i]._objnum];
  1175.     digi_get_sound_loc( &Viewer->orient, &Viewer->pos, Viewer->segnum, 
  1176.                        &objp->pos, objp->segnum, SoundObjects[i].max_volume,
  1177.                        &SoundObjects[i].volume, &SoundObjects[i].pan, SoundObjects[i].max_distance );
  1178.  
  1179.     digi_start_sound_object(i);
  1180.  
  1181.     return SoundObjects[i].signature;
  1182. }
  1183.  
  1184. int digi_link_sound_to_object( int soundnum, short objnum, int forever, fix max_volume )
  1185. {                                                                                                   // 10 segs away
  1186.     return digi_link_sound_to_object2( soundnum, objnum, forever, max_volume, 256*F1_0  );
  1187. }
  1188.  
  1189. int digi_link_sound_to_pos2( int org_soundnum, short segnum, short sidenum, vms_vector * pos, int forever, fix max_volume, fix max_distance )
  1190. {
  1191.     int i, volume, pan;
  1192.     int soundnum;
  1193. #ifdef DEBUG_SOUND
  1194. //    HUD_init_message("pos(org_sn=%d,seg=%d,maxvol=%d,max_dist=%d)",
  1195. //        org_soundnum, segnum, max_volume, max_distance);
  1196. //    printf("pos(org_sn=%d,seg=%d,maxvol=%d,max_dist=%d)\n",
  1197. //        org_soundnum, segnum, max_volume, max_distance);
  1198. #endif
  1199.  
  1200.     soundnum = digi_xlat_sound(org_soundnum);
  1201.  
  1202.     if ( max_volume < 0 ) return -1;
  1203. //  if ( max_volume > F1_0 ) max_volume = F1_0;
  1204.  
  1205.     if (!Digi_initialized) return -1;
  1206.     if (soundnum < 0 ) return -1;
  1207.     if (GameSounds[soundnum].data==NULL) {
  1208.         Int3();
  1209.         return -1;
  1210.     }
  1211.  
  1212.     if ((segnum<0)||(segnum>Highest_segment_index))
  1213.         return -1;
  1214.  
  1215.     if ( !forever ) {
  1216.         // Hack to keep sounds from building up...
  1217.         digi_get_sound_loc( &Viewer->orient, &Viewer->pos, Viewer->segnum, pos, segnum, max_volume, &volume, &pan, max_distance );
  1218.         digi_play_sample_3d( org_soundnum, pan, volume, 0 );
  1219.         return -1;
  1220.     }
  1221.  
  1222.     for (i=0; i<MAX_SOUND_OBJECTS; i++ )
  1223.         if (SoundObjects[i].flags==0)
  1224.             break;
  1225.     
  1226.     if (i==MAX_SOUND_OBJECTS) {
  1227.         mprintf((1, "Too many sound objects!\n" ));
  1228.         return -1;
  1229.     }
  1230.  
  1231.  
  1232.     SoundObjects[i].signature=next_signature++;
  1233.     SoundObjects[i].flags = SOF_USED | SOF_LINK_TO_POS;
  1234.     #ifdef DEBUG_SOUND
  1235.     hp("SOF_PLAYING reset on %d");
  1236.     #endif
  1237.     if ( forever )
  1238.         SoundObjects[i].flags |= SOF_PLAY_FOREVER;
  1239.     SoundObjects[i]._segnum = segnum;
  1240.     SoundObjects[i]._sidenum = sidenum;
  1241.     SoundObjects[i]._position = *pos;
  1242.     SoundObjects[i].soundnum = soundnum;
  1243.     SoundObjects[i].max_volume = max_volume;
  1244.     SoundObjects[i].max_distance = max_distance;
  1245.     SoundObjects[i].volume = 0;
  1246.     SoundObjects[i].pan = 0;
  1247.     digi_get_sound_loc( &Viewer->orient, &Viewer->pos, Viewer->segnum, 
  1248.                        &SoundObjects[i]._position, SoundObjects[i]._segnum, SoundObjects[i].max_volume,
  1249.                        &SoundObjects[i].volume, &SoundObjects[i].pan, SoundObjects[i].max_distance );
  1250.     
  1251.     digi_start_sound_object(i);
  1252.  
  1253.     return SoundObjects[i].signature;
  1254. }
  1255.  
  1256. int digi_link_sound_to_pos( int soundnum, short segnum, short sidenum, vms_vector * pos, int forever, fix max_volume )
  1257. {
  1258.     return digi_link_sound_to_pos2( soundnum, segnum, sidenum, pos, forever, max_volume, F1_0 * 256 );
  1259. }
  1260.  
  1261.  
  1262. void digi_kill_sound_linked_to_segment( int segnum, int sidenum, int soundnum )
  1263. {
  1264.     int i,killed;
  1265.  
  1266.     soundnum = digi_xlat_sound(soundnum);
  1267.  
  1268.     if (!Digi_initialized) return;
  1269.  
  1270.     killed = 0;
  1271.  
  1272.     for (i=0; i<MAX_SOUND_OBJECTS; i++ )    {
  1273.         if ( (SoundObjects[i].flags & SOF_USED) && (SoundObjects[i].flags & SOF_LINK_TO_POS) )  {
  1274.             if ((SoundObjects[i]._segnum == segnum) && (SoundObjects[i].soundnum==soundnum ) && (SoundObjects[i]._sidenum==sidenum) ) {
  1275.                 if ( SoundObjects[i].flags & SOF_PLAYING )  {
  1276.                 #ifdef SOUND_DEBUG
  1277.                     printf("Trying to kill sample\n");
  1278.                 #endif
  1279.                     //sosDIGIStopSample( hSOSDigiDriver, SoundObjects[i].handle );
  1280.                 }
  1281.                 #ifdef DEBUG_SOUND
  1282.                 hp("SOF_PLAYING reset on %d");
  1283.                 #endif
  1284.                 SoundObjects[i].flags = 0;  // Mark as dead, so some other sound can use this sound
  1285.                 ChannelMap[SoundObjects[i].channel] = 0;
  1286.                 killed++;
  1287.             }
  1288.         }
  1289.     }
  1290.     // If this assert happens, it means that there were 2 sounds
  1291.     // that got deleted. Weird, get John.
  1292.     if ( killed > 1 )   {
  1293.         mprintf( (1, "ERROR: More than 1 sounds were deleted from seg %d\n", segnum ));
  1294.     }
  1295. }
  1296.  
  1297. void digi_kill_sound_linked_to_object( int objnum )
  1298. {
  1299.     int i,killed;
  1300. #ifdef DEBUG_SOUND
  1301.     HUD_init_message("Killing sound linked to object %d\n", objnum);
  1302. #endif
  1303.  
  1304.     if (!Digi_initialized) return;
  1305.  
  1306.     killed = 0;
  1307.  
  1308.     for (i=0; i<MAX_SOUND_OBJECTS; i++ )    {
  1309.         if ( (SoundObjects[i].flags & SOF_USED) && (SoundObjects[i].flags & SOF_LINK_TO_OBJ ) ) {
  1310.             if (SoundObjects[i]._objnum == objnum)   {
  1311.                 if ( SoundObjects[i].flags & SOF_PLAYING )  {
  1312.                 #ifdef SOUND_DEBUG
  1313.                     printf("Trying to kill sample\n");
  1314.                 #endif
  1315.                     //sosDIGIStopSample( hSOSDigiDriver, SoundObjects[i].handle );
  1316.                 }
  1317.                 #ifdef DEBUG_SOUND
  1318.                 hp("SOF_PLAYING reset on %d");
  1319.                 #endif
  1320.                 SoundObjects[i].flags = 0;  // Mark as dead, so some other sound can use this sound
  1321.                 ChannelMap[SoundObjects[i].channel] = 0;
  1322.                 killed++;
  1323.             }
  1324.         }
  1325.     }
  1326.     // If this assert happens, it means that there were 2 sounds
  1327.     // that got deleted. Weird, get John.
  1328.     if ( killed > 1 )   {
  1329.         mprintf( (1, "ERROR: More than 1 sounds were deleted from object %d\n", objnum ));
  1330.     }
  1331. }
  1332.  
  1333.  
  1334. void digi_sync_sounds()
  1335. {
  1336.     int i;
  1337.     int oldvolume, oldpan;
  1338.  
  1339.     if (!Digi_initialized) return;
  1340.  
  1341.     for (i=0; i<MAX_SOUND_OBJECTS; i++ )    {
  1342.         if ( SoundObjects[i].flags & SOF_USED ) {
  1343.             oldvolume = SoundObjects[i].volume;
  1344.             oldpan = SoundObjects[i].pan;
  1345.  
  1346.             if ( !(SoundObjects[i].flags & SOF_PLAY_FOREVER) )  {
  1347.                 // Check if its done.
  1348.                 if (SoundObjects[i].flags & SOF_PLAYING) {
  1349.                     if (0 == ChannelMap[SoundObjects[i].channel]) {
  1350.                         SoundObjects[i].flags = 0;  // Mark as dead, so some other sound can use this sound
  1351.                         ChannelMap[SoundObjects[i].channel] = 0;
  1352.                         continue;       // Go on to next sound...
  1353.                     }
  1354.                 }
  1355.             }           
  1356.         
  1357.             if ( SoundObjects[i].flags & SOF_LINK_TO_POS )  {
  1358.                 digi_get_sound_loc( &Viewer->orient, &Viewer->pos, Viewer->segnum, 
  1359.                                 &SoundObjects[i]._position, SoundObjects[i]._segnum, SoundObjects[i].max_volume,
  1360.                                 &SoundObjects[i].volume, &SoundObjects[i].pan, SoundObjects[i].max_distance );
  1361.  
  1362.             } else if ( SoundObjects[i].flags & SOF_LINK_TO_OBJ )   {
  1363.                 object * objp;
  1364.     
  1365.                 objp = &Objects[SoundObjects[i]._objnum];
  1366.         
  1367.                 if ((objp->type==OBJ_NONE) || (objp->signature!=SoundObjects[i]._objsignature))  {
  1368.                     // The object that this is linked to is dead, so just end this sound if it is looping.
  1369.                     if ( (SoundObjects[i].flags & SOF_PLAYING)  && (SoundObjects[i].flags & SOF_PLAY_FOREVER))  {
  1370.                         AHI_SetSound((UWORD)SoundObjects[i].channel,
  1371.                             AHI_NOSOUND, 0,0, AudioCtrl, AHISF_IMM);
  1372.                     }
  1373.                     SoundObjects[i].flags = 0;  // Mark as dead, so some other sound can use this sound
  1374.                     ChannelMap[SoundObjects[i].channel] = 0;
  1375.                     continue;       // Go on to next sound...
  1376.                 } else {
  1377.                     digi_get_sound_loc( &Viewer->orient, &Viewer->pos, Viewer->segnum, 
  1378.                                     &objp->pos, objp->segnum, SoundObjects[i].max_volume,
  1379.                                    &SoundObjects[i].volume, &SoundObjects[i].pan, SoundObjects[i].max_distance );
  1380.                 }
  1381.             }
  1382.              
  1383.             if (oldvolume != SoundObjects[i].volume)    {
  1384.                 if ( SoundObjects[i].volume < 1 )   {
  1385.                     // Sound is too far away, so stop it from playing.
  1386.                     if ((SoundObjects[i].flags & SOF_PLAYING)&&(SoundObjects[i].flags & SOF_PLAY_FOREVER))  {
  1387.                         AHI_SetSound((UWORD)SoundObjects[i].channel,
  1388.                             AHI_NOSOUND, 0,0, AudioCtrl, AHISF_IMM);
  1389.                         SoundObjects[i].flags &= ~SOF_PLAYING;      // Mark sound as not playing
  1390.                         ChannelMap[SoundObjects[i].channel] = 0;
  1391.                     }
  1392.                 } else {
  1393.                     if (!(SoundObjects[i].flags & SOF_PLAYING)) {
  1394.                         digi_start_sound_object(i);
  1395.                     } else {
  1396.                         //sosDIGISetSampleVolume( hSOSDigiDriver,
  1397.                         //    SoundObjects[i].handle,
  1398.                         //    fixmuldiv(SoundObjects[i].volume,
  1399.                         //        digi_volume,F1_0) );
  1400.                         AHI_SetVol((UWORD)SoundObjects[i].channel,
  1401.                             (Fixed)(SoundObjects[i].volume*digi_volume/65535),
  1402.                             (sposition)SoundObjects[i].pan,
  1403.                             AudioCtrl, AHISF_IMM);
  1404.                     }
  1405.                 }
  1406.             }
  1407.         }
  1408.     }
  1409. }
  1410.  
  1411.  
  1412. int sound_paused = 0;
  1413.  
  1414. void digi_pause_all()
  1415. {
  1416.     if (!Digi_initialized) return;
  1417.     sound_paused++;
  1418.  
  1419.     if (sound_paused > 1) return;
  1420.     AHI_ControlAudio(AudioCtrl,
  1421.         AHIC_Play,  FALSE,
  1422.     TAG_DONE);
  1423. }
  1424.  
  1425. void digi_resume_all()
  1426. {
  1427.     if (!Digi_initialized) return;
  1428.     if (sound_paused > 0) sound_paused--;
  1429.     if (sound_paused > 0) return;
  1430.     AHI_ControlAudio(AudioCtrl,
  1431.         AHIC_Play, TRUE,
  1432.     TAG_DONE);
  1433. }
  1434.  
  1435.  
  1436. void digi_stop_all()
  1437. {
  1438.     int i;
  1439.  
  1440.     if (!Digi_initialized) return;
  1441.  
  1442.     for (i=0; i<MAX_SOUND_OBJECTS; i++ )    {
  1443.         if ( SoundObjects[i].flags & SOF_USED ) {
  1444.             #ifdef DEBUG_SOUND
  1445.             hp("SOF_PLAYING reset on %d");
  1446.             #endif
  1447.             SoundObjects[i].flags = 0;  // Mark as dead, so some other sound can use this sound
  1448.         }
  1449.     }
  1450.  
  1451.     for (i=0; i<ahidigi_max_channels; i++) {
  1452.         AHI_SetSound(i, AHI_NOSOUND, 0, 0, AudioCtrl, AHISF_IMM);
  1453.         ChannelMap[i] = 0;
  1454.     }
  1455.  
  1456. }
  1457.  
  1458. #ifndef NDEBUG
  1459. int verify_sound_channel_free( int channel )
  1460. {
  1461.     return 0;
  1462. }
  1463. #endif
  1464.